---
title: 组合优于继承
description: 分析"多用组合少用继承"的设计原则
sidebar_position: 6
---

# 组合优于继承

在面向对象编程中，"组合优于继承"（Composition Over Inheritance）是一条非常重要的设计原则。这个原则建议我们优先使用组合而不是继承来实现代码复用和功能扩展。

## 为什么不推荐使用继承？

虽然继承是面向对象的四大特性之一，可以用来表示类之间的 is-a 关系并实现代码复用，但它也存在以下问题：

1. **继承层次过深**：当继承关系变得复杂时，代码的可读性会变差
2. **破坏封装性**：子类会暴露父类的实现细节
3. **强耦合**：子类与父类高度耦合，父类的修改会影响所有子类
4. **功能组合爆炸**：当类需要多个不同维度的功能时，继承层次会急剧增加

### 示例：鸟类继承的问题

```typescript
// 不好的设计
abstract class AbstractBird {
  fly(): void {
    // 实现飞行逻辑
  }
}

class Ostrich extends AbstractBird {
  // 问题：鸵鸟不会飞，但继承了 fly 方法
  fly(): void {
    throw new Error("I can't fly!");
  }
}
```

## 组合的优势

组合相比继承具有以下优势：

1. **更灵活的代码复用**：可以动态地组合不同的功能
2. **更好的封装性**：不会暴露不必要的实现细节
3. **松耦合**：组件之间的依赖更少
4. **更容易扩展**：添加新功能不会影响现有代码

### 使用组合重构鸟类示例

```typescript
// 定义接口
interface Flyable {
  fly(): void;
}

interface Tweetable {
  tweet(): void;
}

// 实现具体能力
class FlyAbility implements Flyable {
  fly(): void {
    // 飞行实现
  }
}

class TweetAbility implements Tweetable {
  tweet(): void {
    // 鸣叫实现
  }
}

// 通过组合实现功能
class Sparrow {
  private flyAbility = new FlyAbility();
  private tweetAbility = new TweetAbility();

  fly(): void {
    this.flyAbility.fly();  // 委托
  }

  tweet(): void {
    this.tweetAbility.tweet();  // 委托
  }
}

class Ostrich {
  private tweetAbility = new TweetAbility();

  tweet(): void {
    this.tweetAbility.tweet();  // 委托
  }
}
```

## 如何选择使用继承还是组合？

选择使用继承还是组合应该基于以下几个因素：

### 适合使用继承的场景

1. **继承关系稳定**：类之间的关系不太可能改变
2. **继承层次较浅**：最多两到三层继承关系
3. **继承关系简单**：没有复杂的功能组合需求
4. **确实存在 is-a 关系**：子类确实是父类的一种特例

### 适合使用组合的场景

1. **需要更灵活的功能组合**：类需要组合多个不同的功能
2. **继承层次可能变深**：功能的扩展可能导致继承层次变深
3. **需要运行时改变行为**：对象的行为需要在运行时动态改变
4. **存在 has-a 关系**：一个类拥有另一个类的功能，而不是继承关系

### 特殊场景的考虑

某些设计模式会固定使用继承或组合：

- **使用组合**的模式：装饰器模式、策略模式、组合模式
- **使用继承**的模式：模板方法模式

## 实践建议

1. **优先考虑组合**：除非有明确的理由使用继承，否则优先使用组合
2. **保持简单**：无论是继承还是组合，都要保持结构简单清晰
3. **关注变化**：考虑哪些部分可能需要变化，使用组合来处理变化的部分
4. **遵循 SOLID 原则**：特别是单一职责原则和开闭原则

## 总结

组合优于继承并不意味着完全禁止使用继承，而是提醒我们要谨慎使用继承。在实际开发中，应该根据具体场景选择合适的方案：

- 当需要复用代码时，优先考虑组合
- 当确实存在 is-a 关系且继承层次简单时，可以使用继承
- 当不确定时，选择更灵活的组合方案

记住：过度使用继承会导致代码难以维护，而合理使用组合可以帮助我们创建更灵活、可维护的代码。 